// background.js（完整修复版）
// 初始化存储
chrome.runtime.onInstalled.addListener(() => {
  console.log('专注助手扩展已安装/更新');
  chrome.storage.sync.set({ allowedDomains: [] }, () => {
    console.log('初始化域名列表存储');
  });
});

// 从本地存储获取允许的域名列表
async function getAllowedDomains() {
  const result = await chrome.storage.sync.get(['allowedDomains']);
  console.log('获取存储的域名列表:', result.allowedDomains);
  return result.allowedDomains || [];
}

// 检查URL是否匹配允许的模式 - 改进版
function isDomainAllowed(url, allowedPatterns) {
  console.log('检查URL:', url, '允许模式:', allowedPatterns);
  
  // 特殊处理：允许访问chrome扩展页面、新标签页和本地文件
  const specialUrls = [
    'chrome-extension:',
    'chrome://newtab/',
    'localhost',
    '127.'
  ];
  
  if (specialUrls.some(prefix => url.startsWith(prefix))) {
    console.log('允许访问:', url, '(特殊页面)');
    return true;
  }
  
  try {
    const urlObj = new URL(url);
    const hostname = urlObj.hostname;
    
    // 检查是否存在完全匹配的域名
    const exactMatch = allowedPatterns.some(pattern => {
      // 处理带路径的模式
      if (pattern.includes('/')) {
        return new RegExp(`^${pattern.replace(/\*/g, '.*')}$`).test(url);
      }
      // 处理纯域名模式
      return pattern === hostname || 
             pattern === `*.${hostname}` || 
             hostname.endsWith(`.${pattern.replace('*.', '')}`);
    });
    
    if (exactMatch) {
      console.log('允许访问:', url, '(精确匹配)');
      return true;
    }
    
    // 检查是否允许所有子域名
    const wildcardMatch = allowedPatterns.some(pattern => {
      if (pattern.startsWith('*.')) {
        const domainWithoutWildcard = pattern.replace('*.', '');
        return hostname === domainWithoutWildcard || hostname.endsWith(`.${domainWithoutWildcard}`);
      }
      return false;
    });
    
    if (wildcardMatch) {
      console.log('允许访问:', url, '(通配符匹配)');
      return true;
    }
    
    console.log('阻止访问:', url);
    return false;
  } catch (e) {
    console.error('解析URL失败:', e);
    return false;
  }
}

// 发送消息到内容脚本（无重试）
async function sendMessageToContentScript(tabId, message) {
  return new Promise((resolve, reject) => {
    chrome.tabs.sendMessage(tabId, message, (response) => {
      if (chrome.runtime.lastError) {
        console.error('消息发送失败:', chrome.runtime.lastError);
        resolve(false); // 返回失败状态，但不触发错误
      } else {
        console.log('消息发送成功:', message);
        resolve(response);
      }
    });
  });
}

// 注入内容脚本并等待初始化
async function injectContentScript(tabId, message, retryCount) {
  return new Promise((resolve, reject) => {
    chrome.scripting.executeScript({
      target: { tabId },
      files: ['overlay.js']
    }, () => {
      if (chrome.runtime.lastError) {
        console.error('注入内容脚本失败:', chrome.runtime.lastError);
        reject(chrome.runtime.lastError);
        return;
      }
      
      console.log('内容脚本注入成功，等待初始化...');
      
      // 等待内容脚本初始化
      setTimeout(() => {
        sendMessageToContentScript(tabId, message, retryCount)
          .then(resolve)
          .catch(reject);
      }, 1000);
    });
  });
}

// 检查是否为主框架
async function isMainFrame(tabId) {
  return new Promise((resolve) => {
    chrome.webNavigation.getFrame({ tabId, frameId: 0 }, (frameDetails) => {
      // 如果获取失败或frameId为0，表示是主框架
      resolve(!chrome.runtime.lastError || (frameDetails && frameDetails.frameId === 0));
    });
  });
}

// 监听标签页URL变化
chrome.tabs.onUpdated.addListener(async (tabId, changeInfo, tab) => {
  if (changeInfo.url) {
    try {
      console.log('标签页URL变化:', changeInfo.url);
      const isMain = await isMainFrame(tabId);
      if (isMain) {
        checkUrlAndBlock(tabId, changeInfo.url);
      } else {
        console.log('iframe URL变化，忽略:', changeInfo.url);
      }
    } catch (e) {
      console.error('处理URL变化时出错:', e);
    }
  }
});

// 监听标签激活事件（切换标签或刷新页面时触发）
chrome.tabs.onActivated.addListener(async ({ tabId }) => {
  try {
    const tab = await getTab(tabId);
    if (tab && tab.url) {
      console.log('标签激活，URL:', tab.url);
      const isMain = await isMainFrame(tabId);
      if (isMain) {
        checkUrlAndBlock(tabId, tab.url);
      } else {
        console.log('iframe标签激活，忽略:', tab.url);
      }
    }
  } catch (e) {
    console.error('处理标签激活事件时出错:', e);
  }
});

// 监听导航完成事件（包括刷新）
chrome.webNavigation.onCompleted.addListener(async ({ tabId, url, frameId }) => {
  try {
    console.log(`导航完成: tab=${tabId}, frame=${frameId}, url=${url}`);
    
    // 只处理主框架的导航
    if (frameId === 0) {
      console.log('主框架导航，检查URL:', url);
      checkUrlAndBlock(tabId, url);
    } else {
      console.log('iframe导航，忽略:', url);
    }
  } catch (e) {
    console.error('处理导航完成事件时出错:', e);
  }
});

// 封装URL检查和拦截逻辑
async function checkUrlAndBlock(tabId, url) {
  const allowedDomains = await getAllowedDomains();
  const isAllowed = isDomainAllowed(url, allowedDomains);
  
  // 检查是否是主框架（将变量名改为isMain，避免与函数名冲突）
  const isMain = await isMainFrame(tabId);
  
  if (!isAllowed && isMain) {
    console.log('需要提醒访问非白名单网站:', url);
    chrome.storage.local.set({ [`blocked_${tabId}`]: url });
    
    try {
      await sendMessageToContentScript(tabId, { action: 'showOverlay', url });
    } catch (error) {
      console.error('显示遮罩层失败:', error);
    }
  } else {
    chrome.storage.local.remove(`blocked_${tabId}`);
    console.log(isMain ? '允许访问' : 'iframe忽略:', url);
  }
}

// 辅助函数：获取标签信息
function getTab(tabId) {
  return new Promise((resolve, reject) => {
    chrome.tabs.get(tabId, tab => {
      if (chrome.runtime.lastError) {
        reject(chrome.runtime.lastError);
      } else {
        resolve(tab);
      }
    });
  });
}

// 监听域名列表变化，更新相关逻辑
chrome.storage.onChanged.addListener((changes, namespace) => {
  if (namespace === 'sync' && changes.allowedDomains) {
    console.log('域名列表已更新');
  }
});

// 监听来自选项页面的消息
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  console.log('收到消息:', message);
  
  if (message.action === 'updateAllowedDomains') {
    // 获取当前域名列表
    getAllowedDomains().then(currentDomains => {
      // 合并新旧域名列表（保留现有域名）
      const mergedDomains = [...new Set([...currentDomains, ...message.domains])];
      
      chrome.storage.sync.set({ allowedDomains: mergedDomains }, () => {
        console.log('已更新域名列表:', mergedDomains);
        sendResponse({ success: true });
      });
    });
    return true; // 保持消息通道打开直到异步操作完成
  } else if (message.action === 'getAllowedDomains') {
    getAllowedDomains().then(domains => {
      console.log('返回域名列表:', domains);
      sendResponse({ domains });
    });
    return true;
  } else if (message.action === 'checkDomain') {
    const isAllowed = isDomainAllowed(message.url || '', message.allowedPatterns || []);
    console.log(`URL检查结果: ${message.url} => ${isAllowed ? '允许' : '阻止'}`);
    sendResponse({ isAllowed });
    return true;
  } else if (message.action === 'addCurrentUrlToAllowed') {
    // 将当前URL添加到允许列表（精确匹配，不添加/*）
    try {
      const urlObj = new URL(message.url);
      const domainPattern = `${urlObj.origin}${urlObj.pathname}`; // 不添加/*
      
      getAllowedDomains().then(currentDomains => {
        if (!currentDomains.includes(domainPattern)) {
          const updatedDomains = [...currentDomains, domainPattern];
          
          chrome.storage.sync.set({ allowedDomains: updatedDomains }, () => {
            console.log('已添加到允许列表:', domainPattern);
            sendResponse({ success: true, pattern: domainPattern });
            
            // 清除拦截标记
            chrome.storage.local.remove(`blocked_${message.tabId || ''}`);
          });
        } else {
          console.log('已在允许列表中:', domainPattern);
          sendResponse({ success: true, pattern: domainPattern });
        }
      });
    } catch (e) {
      console.error('添加URL到允许列表失败:', e);
      sendResponse({ success: false });
    }
    return true;
  } else if (message.action === 'recordBlockedUrl') {
    chrome.storage.local.set({ [`blocked_${message.tabId}`]: message.url });
    sendResponse({ success: true });
    return true;
  } else if (message.action === 'closeTab') {
    chrome.tabs.query({ active: true, currentWindow: true }, tabs => {
      if (tabs.length) {
        chrome.tabs.remove(tabs[0].id);
      }
    });
    return true;
  }
});